User blog:Rgetar/Creating FGH for transfinite ordinals
Here is FGH: :1. f0(x) = x + 1 :2. fα + 1(x) = fαx(x) :3. fα(x) = fαx(x) iff α is limit (actually it is implied that α is also countable) Here x is a finite number. How to generalize FGH for transfinite x? Transfinite function iteration Here is function iteration for a function f(x): :f0(x) = x :fα + 1(x) = f(fα(x)) In the Rule 2 of FGH "fαx(x)" is used, but we want transfinite x. So, we need to define function iteration fα(x) for a function f(x) also for transfinite α: :f0(x) = x :fα + 1(x) = f(fα(x)) :fα(x) = sup(fβ(x)) for β < α, iff α is limit (that is fα(x) is least ordinal larger than fβ(x) for any β < α) FGH for countable ordinals Let x is a countable ordinal. Then :f0(x) = x + 1 (without changes) :fα + 1(x) = fαx(x) (now transfinite iteration is used) :fα(x) = fαx(x) iff cof(α) = Ω But what if cof(α) = ω? For this case we need another rule: :fα(x) = sup(fβ(x)) for β < α, iff cof(α) = ω General case FGH for finite, or countable, or uncountable x: :1. f0(x) = x + 1 :2. fα + 1(x) = fαx(x) :3. fα(x) = sup(fβ(x)) for β < α, iff 1 < cof(α) ≤ x :4. fα(x) = fαx(x) iff card(x) = Ωn and cof(α) = Ωn + 1 Rule for cof(α) > Ωn + 1 What if card(x) = Ωn and cof(α) = Ωn + 1? For this case we can use another rule: :fα(x) = ffα(Ωm)(x) iff card(x) = Ωn and cof(α) = Ωm + 1 > Ωn + 1 So, the rule set: :1. f0(x) = x + 1 :2. fα + 1(x) = fαx(x) :3. fα(x) = sup(fβ(x)) for β < α, iff 1 < cof(α) ≤ x :4. fα(x) = fαx(x) iff card(x) = Ωn and cof(α) = Ωn + 1 :5. fα(x) = ffα(Ωm)(x) iff card(x) = Ωn and cof(α) = Ωm + 1 > Ωn + 1 Inaccessibles What about weakly inaccessible cardinals, that is what if card(x) = Ωn and cof(α) > Ωn + 1, but there is no m such as cof(α) = Ωm + 1? So far I have no rules for such cases, but I think that if we do not use cardinals larger than least weakly inaccessible cardinal I, then we can use something like :fI(x) = Ωn + 1, where card(x) = Ωn, iff x < I Cofinality Rules for computing cofinality: :1. cof(0) = 0 :2. cof(I) = I (if we use the rule for I) :3. cof(f0(x)) = 1 :4. cof(fI(x)) = fI(x) iff x < I (if we use the rule for I) :5. cof(fαβ(x)) = cof(β) iff β is limit :6. cof(fα(x)) = cof(α) iff 1 < cof(α) ≤ x And other cases can be reduced to these cases using FGH rules. Fundamental sequence algorythm For FGH we also need system of fundamental sequences. Rules for computing elements an of fundamental sequences of a, n < cof(a): :1. 0 has no fundamental sequence :2. In = n (if we use the rule for I) :3. f0(x)n = x (n = 0) :4. fI(x)n = n iff x < I (if we use the rule for I) :5. fαβ(x)n = fαβn(x) iff β is limit :6. fα(x)n = fαn(x) iff 1 < cof(α) ≤ x And other cases can be reduced to these cases using FGH rules. Standard forms But this fundamental sequence algorythm is not yet a system of fundamental sequences, since it can produce different fundamental sequences for the same ordinal, expressed using FGH in different ways. So we should choose one FGH standard form for an ordinal. We can use rule: forms, produced by the fundamental sequence algorythm applied to standard forms, are also standard. And we should define that some expressions of large ordinals are standard forms. (But it still does not quarantee unique fundamental sequences for ordinals). We can try to use such rules (for ordinals less than Ωω): :1. Finite numbers in decimal form are standard forms :2. Ωn for finite n are standard forms :3. fΩm(Ωn) for finite n, m, m > n, are standard forms :4. The fundamental sequence algorythm applied to standard forms produces standard forms Examples :f0(ω) = ω + 1 :f02(ω) = ω + 2 :f03(ω) = ω + 3 :f04(ω) = ω + 4 :f05(ω) = ω + 5 :f1(ω) = ω2 :f12(ω) = ω4 :f13(ω) = ω8 :f14(ω) = ω16 :f15(ω) = ω32 :f2(ω) = ω2 :f22(ω) = ωω :f23(ω) = ωωω :f24(ω) = ωωωω :f25(ω) = ωωωωω :f3(ω) = ε0 :f32(ω) = εε0 :f33(ω) = εεε0 :f34(ω) = εεεε0 :f35(ω) = εεεεε0 :f4(ω) = ζ0 :f42(ω) = ζζ0 :f43(ω) = ζζζ0 :f44(ω) = ζζζζ0 :f45(ω) = ζζζζζ0 :f5(ω) = η0 :f52(ω) = ηη0 :f53(ω) = ηηη0 :f54(ω) = ηηηη0 :f55(ω) = ηηηηη0 :f6(ω) = φ(4, 0) :f62(ω) = φ(4, φ(4, 0)) :f63(ω) = φ(4, φ(4, φ(4, 0))) :f64(ω) = φ(4, φ(4, φ(4, φ(4, 0)))) :f65(ω) = φ(4, φ(4, φ(4, φ(4, φ(4, 0))))) :f7(ω) = φ(5, 0) :f72(ω) = φ(5, φ(5, 0)) :f73(ω) = φ(5, φ(5, φ(5, 0))) :f74(ω) = φ(5, φ(5, φ(5, φ(5, 0)))) :f75(ω) = φ(5, φ(5, φ(5, φ(5, φ(5, 0))))) :fΩ(ω) = φ(ω, 0) :fΩ2(ω) = φ(φ(ω, 0), 0) :fΩ3(ω) = φ(φ(φ(ω, 0), 0), 0) :fΩ4(ω) = φ(φ(φ(φ(ω, 0), 0), 0), 0) :fΩ5(ω) = φ(φ(φ(φ(φ(ω, 0), 0), 0), 0), 0) :ff0(Ω)(ω) = Γ0 :ff0(Ω)2(ω) = φ(1, 0, Γ0) :ff0(Ω)3(ω) = φ(1, 0, φ(1, 0, Γ0)) :ff0(Ω)4(ω) = φ(1, 0, φ(1, 0, φ(1, 0, Γ0))) :ff0(Ω)5(ω) = φ(1, 0, φ(1, 0, φ(1, 0, φ(1, 0, Γ0)))) :ff02(Ω)(ω) = φ(1, 1, 0) :ff02(Ω)2(ω) = φ(1, 1, φ(1, 1, 0)) :ff02(Ω)3(ω) = φ(1, 1, φ(1, 1, φ(1, 1, 0))) :ff02(Ω)4(ω) = φ(1, 1, φ(1, 1, φ(1, 1, φ(1, 1, 0)))) :ff02(Ω)5(ω) = φ(1, 1, φ(1, 1, φ(1, 1, φ(1, 1, φ(1, 1, 0))))) :ff03(Ω)(ω) = φ(1, 2, 0) :ff03(Ω)2(ω) = φ(1, 2, φ(1, 2, 0)) :ff03(Ω)3(ω) = φ(1, 2, φ(1, 2, φ(1, 2, 0))) :ff03(Ω)4(ω) = φ(1, 2, φ(1, 2, φ(1, 2, φ(1, 2, 0)))) :ff03(Ω)5(ω) = φ(1, 2, φ(1, 2, φ(1, 2, φ(1, 2, φ(1, 2, 0))))) :ff04(Ω)(ω) = φ(1, 3, 0) :ff04(Ω)2(ω) = φ(1, 3, φ(1, 3, 0)) :ff04(Ω)3(ω) = φ(1, 3, φ(1, 3, φ(1, 3, 0))) :ff04(Ω)4(ω) = φ(1, 3, φ(1, 3, φ(1, 3, φ(1, 3, 0)))) :ff04(Ω)5(ω) = φ(1, 3, φ(1, 3, φ(1, 3, φ(1, 3, φ(1, 3, 0))))) :ff05(Ω)(ω) = φ(1, 4, 0) :ff05(Ω)2(ω) = φ(1, 4, φ(1, 4, 0)) :ff05(Ω)3(ω) = φ(1, 4, φ(1, 4, φ(1, 4, 0))) :ff05(Ω)4(ω) = φ(1, 4, φ(1, 4, φ(1, 4, φ(1, 4, 0)))) :ff05(Ω)5(ω) = φ(1, 4, φ(1, 4, φ(1, 4, φ(1, 4, φ(1, 4, 0))))) :ff1(Ω)(ω) = φ(1, ω, 0) :ff1(Ω)2(ω) = φ(1, φ(1, ω, 0), 0) :ff1(Ω)3(ω) = φ(1, φ(1, φ(1, ω, 0), 0), 0) :ff1(Ω)4(ω) = φ(1, φ(1, φ(1, φ(1, ω, 0), 0), 0), 0) :ff1(Ω)5(ω) = φ(1, φ(1, φ(1, φ(1, φ(1, φ(1, ω, 0), 0), 0), 0), 0), 0) :ff2(Ω)(ω) = φ(ω, 0, 0) :ff2(Ω)2(ω) = SVO :ff3(Ω)(ω) = BHO Some general rules for infinite x: :f0(x) = x + 1 :f0n(x) = x + n :f1(x) = x2 :f1n(x) = x2n :f2(x) = x2x :f2ω(x) is next ε number after x :f2ωn(x) is n-th next ε number after x :f3ω(x) is next ζ number after x :f3ωn(x) is n-th next ζ number after x :fαω(x), where α is next Ω number after x, is next Γ number after x :fαωn(x), where α is next Ω number after x, is n-th next Γ number after x Other formats Also I was thinking about other formats for designation of FGH, for example, (α0.n0, α1.n1, α2.n2, ... αk.nk) format, used in FGH-based notation for finite numbers in my previous blog, or "booster-base" format, like used in my programs, but this time "double booster" is used: :X.Yα = fXY(α) By the way, I already was thinking about transfinite number of boosters, since I thought that ω is used in my notation too often, but then I rejected that idea, because I thought that it would complicate the notation. But now I am not sure, which notation is simpler - with "single boosters", or "double boosters": "double boosters" are simpler because :XXXXXXXα can be replaced with :X.7α Also it is stronger, since there can be :X.ωα :+ 1α :... which is impossible in "single boosters", but "single boosters" are simpler, since they use only one entry in a booster, and do not use ".". Category:Blog posts